package com.cloud.core.utils;

import android.text.TextUtils;

import java.math.BigDecimal;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @Author： Chen
 * @Date： 2020/1/17
 * @Desc：
 */
public class NumberUtils {
    public static boolean isNumStr(String str) {
        Pattern pattern = Pattern.compile("-?[0-9]+\\.?[0-9]*");
        Matcher isNum = pattern.matcher(str);
        if (!isNum.matches()) {
            return false;
        }
        return true;
    }

    /**
     * 对象是否为无效值
     *
     * @param obj 要判断的对象
     * @return 是否为有效值（不为null 和 "" 字符串）
     */
    public static boolean isNullOrEmpty(Object obj) {
        return obj == null || "".equals(obj.toString());
    }

    /**
     * 参数是否是有效数字 （整数或者小数）
     *
     * @param obj 参数（对象将被调用string()转为字符串类型）
     * @return 是否是数字
     */
    public static boolean isNumber(Object obj) {
        if (obj instanceof Number) return true;
        return isInt(obj) || isDouble(obj);
    }

    /**
     * 参数是否是有效整数
     *
     * @param obj 参数（对象将被调用string()转为字符串类型）
     * @return 是否是整数
     */
    public static boolean isInt(Object obj) {
        if (isNullOrEmpty(obj))
            return false;
        if (obj instanceof Integer)
            return true;
        return obj.toString().matches("[-+]?\\d+");
    }

    /**
     * 字符串参数是否是double
     *
     * @param obj 参数（对象将被调用string()转为字符串类型）
     * @return 是否是double
     */
    public static boolean isDouble(Object obj) {
        if (isNullOrEmpty(obj))
            return false;
        if (obj instanceof Double || obj instanceof Float)
            return true;
        return compileRegex("[-+]?\\d+\\.\\d+").matcher(obj.toString()).matches();
    }

    /**
     * 编译后的正则表达式缓存
     */
    private static final Map<String, Pattern> PATTERN_CACHE = new ConcurrentHashMap<>();

    /**
     * 编译一个正则表达式，并且进行缓存,如果缓存已存在则使用缓存
     *
     * @param regex 表达式
     * @return 编译后的Pattern
     */
    public static final Pattern compileRegex(String regex) {
        Pattern pattern = PATTERN_CACHE.get(regex);
        if (pattern == null) {
            pattern = Pattern.compile(regex);
            PATTERN_CACHE.put(regex, pattern);
        }
        return pattern;
    }


    /**
     * 数字转换为字符串
     *
     * @param num 数字
     * @return 字符串, 如果 num 为空, 返回空字符串
     */
    public static String num2obj(Object num) {
        String str = null;

        if (num == null) {
            str = "";
        } else {
            str = String.valueOf(num);
        }
        return str;
    }

    /**
     * 字符串转换为Integer
     *
     * @param obj 字符串
     * @return Integer, obj为null时返回0
     */
    public static Integer getInteger(Object obj) {
        return getInteger(obj, 0);
    }

    /**
     * 字符串转换为Integer
     *
     * @param obj 字符串
     * @param def 默认值
     * @return Integer, 字符串为null时返回def
     */
    public static Integer getInteger(Object obj, int def) {
        String str = obj == null ? "" : obj.toString();

        Integer i = null;

        if (str.trim().length() == 0) {
            i = Integer.valueOf(def);
        } else {
            try {
                i = Integer.valueOf(str);
            } catch (Exception e) {
            }
        }

        return i == null ? Integer.valueOf(def) : i;
    }

    /**
     * 字符串转换为Float
     *
     * @param obj 字符串
     * @param def 默认值
     * @return Float, 字符串为null时返回def
     */
    public static Float getFloat(Object obj, float def) {
        String str = obj == null ? "" : obj.toString();

        Float i = null;

        if (str.trim().length() == 0) {
            i = Float.valueOf(def);
        } else {
            try {
                i = Float.valueOf(str);
            } catch (Exception e) {
            }
        }

        return i == null ? Float.valueOf(def) : i;
    }

    /**
     * 字符串转换为Float
     *
     * @param obj 字符串
     * @return Float, obj为null时返回0
     */
    public static Float getFloat(Object obj) {
        return getFloat(obj, 0);
    }

    /**
     * 字符串转换为Double
     *
     * @param obj 字符串
     * @param def 默认值
     * @return Double, 字符串为null时返回def
     */
    public static Double getDouble(Object obj, double def) {
        String str = obj == null ? "" : obj.toString();

        Double i = null;

        if (str.trim().length() == 0) {
            i = Double.valueOf(def);
        } else {
            try {
                i = Double.valueOf(str);
            } catch (Exception e) {
            }
        }

        return i == null ? Double.valueOf(def) : i;
    }

    /**
     * 字符串转换为Double
     *
     * @param obj 字符串
     * @return Double, obj为null时返回0
     */
    public static Double getDouble(Object obj) {
        return getDouble(obj, 0);
    }

    /**
     * 字符串转换为Long
     *
     * @param obj 字符串
     * @param def 默认值
     * @return Long, 字符串为null时返回def
     */
    public static Long getLong(Object obj, long def) {
        String str = obj == null ? "" : obj.toString();

        Long l = null;

        if (str.trim().length() == 0) {
            l = Long.valueOf(def);
        } else {
            try {
                l = Long.valueOf(str);
            } catch (Exception e) {
            }
        }

        return l == null ? Long.valueOf(def) : l;
    }

    /**
     * 字符串转换为Long
     *
     * @param obj 字符串
     * @return Long, obj为null时返回0
     */
    public static Long getLong(Object obj) {
        return getLong(obj, 0);
    }

    /**
     * 字符串转换为Integer
     *
     * @param obj 字符串
     * @return Integer, obj为null时返回0
     */
    public static int getIntegerValue(Object obj) {
        return getIntegerValue(obj, 0);
    }

    /**
     * 字符串转换为Integer
     *
     * @param obj 字符串
     * @param def 默认值
     * @return Integer, 字符串为null时返回def
     */
    public static int getIntegerValue(Object obj, int def) {
        return getInteger(obj, def).intValue();
    }

    /**
     * 字符串转换为float
     *
     * @param obj 字符串
     * @return float, obj为null时返回0
     */
    public static float getFloatValue(Object obj) {
        return getFloatValue(obj, 0);
    }

    /**
     * 字符串转换为float
     *
     * @param obj 字符串
     * @param def 默认值
     * @return float, 字符串为null时返回def
     */
    public static float getFloatValue(Object obj, float def) {
        return getFloat(obj, def).floatValue();
    }

    /**
     * 字符串转换为double
     *
     * @param obj 字符串
     * @return double, obj为null时返回0
     */
    public static double getDoubleValue(Object obj) {
        return getDoubleValue(obj, 0);
    }

    /**
     * 字符串转换为double
     *
     * @param obj 字符串
     * @param def 默认值
     * @return double, 字符串为null时返回def
     */
    public static double getDoubleValue(Object obj, double def) {
        return getDouble(obj, def).doubleValue();
    }

    /**
     * 字符串转换为Long
     *
     * @param obj 字符串
     * @return Long, obj为null时返回0
     */
    public static long getLongValue(Object obj) {
        return getLongValue(obj, 0);
    }

    /**
     * 字符串转换为Long
     *
     * @param obj 字符串
     * @param def 默认值
     * @return Long, 字符串为null时返回def
     */
    public static long getLongValue(Object obj, long def) {
        return getLong(obj, def).longValue();
    }

    /**
     * 加法运算
     *
     * @param v1
     * @param v2
     * @return
     */
    public static String bigAdd(String v1, String v2) {
        if (TextUtils.isEmpty(v1)) {
            v1 = "0";
        }
        if (TextUtils.isEmpty(v2)) {
            v2 = "0";
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2).toString();
    }

    /**
     * 减法运算
     *
     * @param v1
     * @param v2
     * @return
     */
    public static String bigSubtract(String v1, String v2) {
        if (TextUtils.isEmpty(v1)) {
            v1 = "0";
        }
        if (TextUtils.isEmpty(v2)) {
            v2 = "0";
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2).toString();
    }

    /**
     * 乘法运算
     *
     * @param v1
     * @param v2
     * @return
     */
    public static String bigMultiply(String v1, String v2) {
        if (TextUtils.isEmpty(v1)) {
            v1 = "0";
        }
        if (TextUtils.isEmpty(v2)) {
            v2 = "0";
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).toString();
    }

    /**
     * 除法运算
     *
     * @param v1
     * @param v2
     * @return
     */
    public static String bigDivide(String v1, String v2) {
        if (TextUtils.isEmpty(v1)) {
            v1 = "0";
        }
        if (TextUtils.isEmpty(v2)) {
            return "0";
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.divide(b2).toString();
    }

    /**
     * 取余运算
     *
     * @param v1
     * @param v2
     * @return
     */
    public static String bigRemainder(String v1, String v2) {
        if (TextUtils.isEmpty(v1)) {
            return "0";
        }
        if (TextUtils.isEmpty(v2)) {
            return "0";
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.remainder(b2).toString();
    }
}
